package objectOriented;  // 添加包声明

/**
 * Java类的特性详解
 */
public class JavaClassFeatures {
    
    // 1. 成员变量（属性）演示
    private String instanceVariable;        // 实例变量
    private static String staticVariable;   // 静态变量
    public final double PI = 3.14159;      // 常量
    
    // 2. 构造方法
    public JavaClassFeatures() {
        // 无参构造方法
    }
    
    public JavaClassFeatures(String instanceVariable) {
        this.instanceVariable = instanceVariable;  // this关键字使用
    }
    
    // 3. 成员方法
    public void instanceMethod() {
        // 实例方法
        System.out.println("这是实例方法");
    }
    
    public static void staticMethod() {
        // 静态方法
        System.out.println("这是静态方法");
    }
    
    // 4. 方法重载示例
    public void display(String message) {
        System.out.println(message);
    }
    
    public void display(String message, int times) {
        for(int i = 0; i < times; i++) {
            System.out.println(message);
        }
    }
    
    // 5. 内部类示例
    public class InnerClass {
        public void innerMethod() {
            System.out.println("这是内部类方法");
        }
    }
    
    // 6. 静态内部类
    public static class StaticInnerClass {
        public void staticInnerMethod() {
            System.out.println("这是静态内部类方法");
        }
    }
    
    // 7. 访问控制示例
    private void privateMethod() {
        // 私有方法，只能在类内部访问
    }
    
    protected void protectedMethod() {
        // 受保护方法，可以被子类和同包类访问
    }
    
    void defaultMethod() {
        // 默认访问权限，同包可访问
    }
    
    public void publicMethod() {
        // 公共方法，任何地方都可访问
    }
    
    // 添加主函数
    public static void main(String[] args) {
        // 创建类的实例
        JavaClassFeatures demo = new JavaClassFeatures("测试实例");
        demo.instanceMethod();
        
        // 调用静态方法
        staticMethod();
        
        // 测试方法重载
        demo.display("Hello");
        demo.display("Hello", 3);
        
        // 测试内部类 - 修改这里
        // 原代码：JavaClassFeatures.InnerClass inner = demo.new InnerClass();
        InnerClass inner = demo.new InnerClass();  // 使用已创建的实例demo来创建内部类
        inner.innerMethod();
        
        // 测试静态内部类 - 这行不需要修改，因为StaticInnerClass是静态的
        JavaClassFeatures.StaticInnerClass staticInner = new JavaClassFeatures.StaticInnerClass();
        staticInner.staticInnerMethod();
        
        // 测试继承
        ChildClass child = new ChildClass();
        child.display("测试继承");
        
        // 测试接口实现
        ImplementClass impl = new ImplementClass();
        impl.interfaceMethod();
        
        // 测试static修饰符
        System.out.println("\n=== 测试static修饰符 ===");
        StaticExample.counter = 1;  // 直接通过类名访问static变量
        StaticExample.incrementCounter();  // 直接通过类名调用static方法
        System.out.println("计数器值: " + StaticExample.counter);  // 输出2
        
        // 测试static内部类
        StaticExample.InnerClass innerObj = new StaticExample.InnerClass();
        innerObj.display();
        
        // 测试abstract修饰符
        System.out.println("\n=== 测试abstract修饰符 ===");
        // Animal animal = new Animal(); // 错误：不能实例化抽象类
       Dog dog = new Dog();
//        dog.makeSound();  // 输出：汪汪汪！
//        dog.sleep();      // 输出：动物在睡觉
        
        // 测试final修饰符
        System.out.println("\n=== 测试final修饰符 ===");
//        FinalClass finalObj = new FinalClass();
//        System.out.println("常量值: " + finalObj.MAX_VALUE);
//        finalObj.display();
        
        // 测试final参数
//        Example example = new Example();
//        example.process(100);
    }

    
public class StaticExample {
    // static变量
    static int counter = 0;
    
    // static方法
    static void incrementCounter() {
        counter++;
    }
    
    // static代码块
    static {
        System.out.println("类加载时执行");
    }
    
    // static内部类
    static class InnerClass {
        void display() {
            System.out.println("静态内部类");
        }
    }
}

public static abstract class Animal {
    // 抽象方法
    abstract void makeSound();
    
    // 普通方法
    void sleep() {
        System.out.println("动物在睡觉");
    }
}

public static class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("汪汪汪！");
    }
}

final class FinalClass {
    // final变量（常量）
    final int MAX_VALUE = 100;
    
    // final方法
    final void display() {
        System.out.println("此方法不能被重写");
    }
}

class Example {
    // final参数
    void process(final int value) {
        // value = 10; // 错误：不能修改final参数
        System.out.println(value);
    }
}

public abstract class CombinedExample {
    // static final常量
    static final double PI = 3.14159;
    
    // abstract方法
    abstract void calculate();
    
    // static final方法
    static final void utility() {
        System.out.println("工具方法");
    }
} 
}

// 8. 继承示例
class ChildClass extends JavaClassFeatures {
    // @Override
    public void display(String message) {
        // 方法重写
        System.out.println("子类重写: " + message);
    }
}

// 9. 接口实现示例
interface MyInterface {
    void interfaceMethod();
}

class ImplementClass implements MyInterface {
    @Override
    public void interfaceMethod() {
        System.out.println("实现接口方法");
    }
}


